package com.ffggffgfv.backend.controller;

import com.ffggffgfv.backend.dto.PageResult;
import com.ffggffgfv.backend.dto.ProductQueryDTO;
import com.ffggffgfv.backend.entity.Product;
import com.ffggffgfv.backend.service.ProductService;
import com.ffggffgfv.backend.util.JWTUtil;
import com.ffggffgfv.backend.util.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 商品控制器
 */
@RestController
@RequestMapping("/api/products")
public class ProductController {

    @Autowired
    private ProductService productService;

    @Autowired
    private JWTUtil jwtUtil;

    /**
     * 查询所有商品（不分页，已过时）
     *
     * @return 商品列表
     */
    @GetMapping("/all")
    public Result getAllProducts() {
        List<Product> products = productService.findAll();
        return Result.success(products, "获取商品列表成功");
    }

    /**
     * 分页查询商品
     *
     * @param name       商品名称（模糊查询）
     * @param categoryId 分类ID
     * @param status     商品状态（0-下架 1-上架）
     * @param merchantId 商家ID
     * @param pageNum    页码（默认1）
     * @param pageSize   每页大小（默认10）
     * @return 分页结果
     */
    @GetMapping
    public Result getProductsByPage(
            @RequestParam(required = false) String name,
            @RequestParam(required = false) Long categoryId,
            @RequestParam(required = false) Integer status,
            @RequestParam(required = false) Long merchantId,
            @RequestParam(required = false, defaultValue = "1") Integer pageNum,
            @RequestParam(required = false, defaultValue = "10") Integer pageSize) {

        // 组装查询条件
        ProductQueryDTO queryDTO = new ProductQueryDTO();
        queryDTO.setName(name);
        queryDTO.setCategoryId(categoryId);
        queryDTO.setStatus(status);
        queryDTO.setMerchantId(merchantId);
        queryDTO.setPageNum(pageNum);
        queryDTO.setPageSize(pageSize);

        // 分页查询
        PageResult<Product> pageResult = productService.findByPage(queryDTO);

        // 返回结果，带上总记录数作为备注
        return Result.success(pageResult, "共" + pageResult.getTotal() + "条记录");
    }

    /**
     * 搜索商品（模糊匹配名称和描述）
     *
     * @param keyword 关键字
     * @param limit   返回数量限制，默认20条
     * @return 匹配的商品列表
     */
    @GetMapping("/search")
    public Result searchProducts(
            @RequestParam String keyword,
            @RequestParam(required = false, defaultValue = "20") Integer limit) {

        if (keyword == null || keyword.trim().isEmpty()) {
            return Result.validateFailed("关键字不能为空");
        }

        // 限制搜索返回数量，避免返回过多数据
        if (limit > 100) {
            limit = 100;
        }

        List<Product> products = productService.searchByKeyword(keyword, limit);

        return Result.success(products, "搜索成功，共找到 " + products.size() + " 个匹配项");
    }

    /**
     * 根据ID查询商品详情
     *
     * @param id 商品ID
     * @return 商品详情
     */
    @GetMapping("/{id}")
    public Result getProductById(@PathVariable Long id) {
        Product product = productService.findById(id);
        if (product == null) {
            return Result.validateFailed("商品不存在");
        }
        return Result.success(product, "获取商品详情成功");
    }

    /**
     * 根据分类ID查询商品列表
     *
     * @param categoryId 分类ID
     * @param pageNum    页码（默认1）
     * @param pageSize   每页大小（默认10）
     * @return 分页商品列表
     */
    @GetMapping("/category/{categoryId}")
    public Result getProductsByCategory(
            @PathVariable Long categoryId,
            @RequestParam(required = false, defaultValue = "1") Integer pageNum,
            @RequestParam(required = false, defaultValue = "10") Integer pageSize) {

        PageResult<Product> pageResult = productService.findByCategoryId(categoryId, pageNum, pageSize);
        return Result.success(pageResult, "共" + pageResult.getTotal() + "条记录");
    }

    /**
     * 创建商品（管理员接口）
     *
     * @param product 商品对象
     * @param token   JWT令牌
     * @return 创建结果
     */
    @PostMapping
    public Result createProduct(@RequestBody Product product, @RequestHeader(value = "Authorization") String token) {
        // 从令牌中获取用户信息并验证权限
        if (!validateAdminPermission(token)) {
            return Result.unauthorized("无权操作");
        }

        // 参数校验
        if (product.getName() == null || product.getName().trim().isEmpty()) {
            return Result.validateFailed("商品名称不能为空");
        }
        if (product.getPrice() == null) {
            return Result.validateFailed("商品价格不能为空");
        }
        if (product.getCategoryId() == null) {
            return Result.validateFailed("商品分类不能为空");
        }
        if (product.getMerchantId() == null) {
            return Result.validateFailed("所属商家不能为空");
        }

        Product createdProduct = productService.create(product);
        return Result.success(createdProduct, "创建商品成功");
    }

    /**
     * 更新商品（管理员接口）
     *
     * @param id      商品ID
     * @param product 商品对象
     * @param token   JWT令牌
     * @return 更新结果
     */
    @PutMapping("/{id}")
    public Result updateProduct(
            @PathVariable Long id,
            @RequestBody Product product,
            @RequestHeader(value = "Authorization") String token) {

//        // 从令牌中获取用户信息并验证权限
//        if (!validateAdminPermission(token)) {
//            return Result.unauthorized("无权操作");
//        }

        Product updatedProduct = productService.update(id, product);
        if (updatedProduct == null) {
            return Result.validateFailed("更新失败，商品不存在");
        }

        return Result.success(updatedProduct, "更新商品成功");
    }

    /**
     * 删除商品（管理员接口）
     *
     * @param id    商品ID
     * @param token JWT令牌
     * @return 删除结果
     */
    @DeleteMapping("/{id}")
    public Result deleteProduct(@PathVariable Long id, @RequestHeader(value = "Authorization") String token) {
        // 从令牌中获取用户信息并验证权限
        if (!validateAdminPermission(token)) {
            return Result.unauthorized("无权操作");
        }

        boolean result = productService.delete(id);
        if (result) {
            return Result.success(null, "删除商品成功");
        } else {
            return Result.validateFailed("删除失败，商品不存在");
        }
    }

    /**
     * 更新商品状态（上架/下架）（管理员接口）
     *
     * @param id     商品ID
     * @param status 状态（0-下架 1-上架）
     * @param token  JWT令牌
     * @return 更新结果
     */
    @PutMapping("/{id}/status")
    public Result updateProductStatus(
            @PathVariable Long id,
            @RequestParam Integer status,
            @RequestHeader(value = "Authorization") String token) {

        // 从令牌中获取用户信息并验证权限
        if (!validateAdminPermission(token)) {
            return Result.unauthorized("无权操作");
        }

        // 参数校验
        if (status != 0 && status != 1) {
            return Result.validateFailed("状态值无效");
        }

        Product updatedProduct = productService.updateStatus(id, status);
        if (updatedProduct == null) {
            return Result.validateFailed("更新失败，商品不存在");
        }

        String statusText = status == 1 ? "上架" : "下架";
        return Result.success(updatedProduct, "商品" + statusText + "成功");
    }

    /**
     * 验证是否有管理员权限
     *
     * @param token JWT令牌
     * @return 是否有权限
     */
    private boolean validateAdminPermission(String token) {
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                // 在实际系统中，应该从令牌中解析用户角色，并验证是否具有管理员权限
                // 这里简化处理，假设验证成功
                return true;
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }
}
